package com.niit.scala

import scala.io.StdIn

/**
 * Date:2025/3/10
 * Author：Ys
 * Description:
 */
object Base03 {

  def main(args: Array[String]): Unit = {
    /*
    1.三引号： ‘’ ：字符  ”“： 字符串 ”“”“”“：多行字符串，可以保存字符串的格式（换行 和 空格）
        常用于在Spark写SQL
     */
    val str1 =
      """
        |lalal
        |lalla
        |   adsfj
        |""".stripMargin
    println(str1)

    //2.惰性赋值。当使用惰性赋值时，变量的值不会被立即计算，而是会在使用时才计算  关键字：lazy
    //格式： lazy val 变量 = 值
    lazy val name = "张三"
    println(name)

    /*
    3.数值类型转换： 1.自动数据类型转换：用大的数据类型去装载小的数据类型
                   2.手动数据类型转换：用小的数据类型去装载大的数据类型 （显示转换、强制转换）
                      缺点：可能会损失精度
         从小到大的数据类型依次为：byte - short - int - long - float - double
     */
    //3.1自动转换
    var a:Int = 10
    var b:Long = a
    var c:Double = a +3.14
    println(a,b,c)
    //3.2手动转换
    //格式： val/var 变量名:数据类型 = 数值.toXxx (Xxx:要转换的数据类型)
    var d:Double = 3.14
    var e:Int = d.toInt
    println(d,e)
    //3.3值类型与String之间的转换
    val f:Int = 18
     //字符串拼接法：任意类型对字符串进行拼接，最终类型都是字符串
    val g:String = f + ""
    //格式： val/var 变量名:String = 数值.toString
    val h:String = f.toString
    //3.4String类型变成值类型
    //格式： val/var 变量名:数据类型 = 数值.toXxx (Xxx:要转换的数据类型)
    val i:Int = "18".toInt
    println(i)

    /*
    4.键盘录入：字符串的键盘录入：StdIn.readLine()
     * 键盘录入：数值的键盘录入：StdIn.readInt()
     * 键盘录入：字符的键盘录入：StdIn.readChar()
     * 键盘录入：布尔值的键盘录入：StdIn.readBoolean()
     * 键盘录入：浮点数的键盘录入：StdIn.readFloat()
     * 键盘录入：双精度浮点数的键盘录入：StdIn.readDouble()
     * 键盘录入：长整型的键盘录入：StdIn.readLong()
     * 键盘录入：短整型的键盘录入：StdIn.readShort()
     * 键盘录入：字节型的键盘录入：StdIn.readByte()

    println("请输入你最大的愿望：")
    val str = StdIn.readLine()
    println("我的最大愿望是："+str)
      */

    //5.余数
    var q = 27 % 5 //   27 - 27/5 * 5  = 27 - 5 * 5  = 27 - 25 = 2
    b+=a // b=10 a= 10 b+=a  b=b+a
    var w = "abc".eq("egf")
    println(q,b,w)

    //6.逻辑运算符： &&：与   ||：或  ! ：非
    println( 1>2  && 4>3) // false
    println(2>0 && 11> 8 ) //true

    println(1>2 || 2>1)// true
    println(2>0 || 11>8) //true

    println(! (1>2 || 2> 1) )//false

    //7 if else if else
    var score = 80
    //90-100 优秀 80-90 良好 0-80中等 其他成绩 无效
    if(score>=90 && score<=100){
      println("优秀")
    }else if(score>=80 && score<90){
      println("良好")
    }else if(score>=0 && score<80){
      println("中等")
    }else {
      println("无效")
    }
    //8. Java 三目(元)运算符 ：int a = 2>1 ? 2 : 1
    // Scala 三目运算符：val a = if(2>1) 2 else 1
    val res = if(2>1) 2 else 1
    println(res)

    //9.代码块 -- 块表达式   {  代码 }
    //代码块表达式  val a = {代码 }
    //代码块中的最后一句是返回语句
    val kuai = {
      if(2>1){
        println("成立")
      }
      1+1
      3+3
      4+4
    }
    println(kuai)

    //10.for 循环
    //格式： for(i <- 表达式/集合)
    for(i <- 1 to 10){
      println(i)
    }
   val num = 1 to 10 //[1,2,3,4,5,6,7,8,9,10]
   for(i <- num){
     println(i)
   }

    //11.for循环的守卫
    //for表达式中，可以添加if判断语句，这个if称之为守卫，过滤数据
    //格式： for(i <- 表达式/集合 if 条件)
    //输入1-10的偶数
    for (i <- 1 to 10 if i%2==0) {
      println(i)
    }

    //12.for的循环推导式
    // for循环也是有返回值的，可以yield对for循环的数据进行返回一个集合
    //对1-10 每个数扩大十倍，返回一个集合
    val v = for(i <- 1 to 10) yield i * 10
    //v [10,20,30,40,50,60,70,80,90,100]
    println(v)

    //13. while  do-while
    // 需求 利用while循环输出1-10  利用do-while循环 输出10-1
    var count = 1
    while (count<=10){
      println(count)
      count+=1
    }
    do{
      println(count)
      count-=1
    }while (count>=1)
    //14 break 和 continue  --> Scala没有continue关键字
    //Scala要想使用break需要for循环的外面套一层breakable
    import scala.util.control.Breaks.{break,breakable}
    //需求：利用for循环输出1-0，当输出到5的时候就结束循环
    breakable{
      for (i <- 1 to 10) {
        if (i == 5) {
          break
        }
        println(i)
      }
    }
    //需求：用 for 循环输出1-10，当输出到3的时候就跳过本次循环  -- continue
    // 在Scala中想用continue的功能，需要for循环中的if外面套一层breakable
    for (i <- 1 to 10) {
      breakable{
        if (i==3){
          break
        }else{
          println(i)
        }
      }
    }

    /*15.方法
      def 方法名(参数名:参数类型,参数名:参数类型):[返回类型]={
        方法体
      }
      注意： 参数列表的参数类型是不能省略的
            返回类型是可以省略，Scala编译器会自动推断
            返回值可以不写return ，默认就是块表达式的值
     */
    val max = getMax(b=10,a=20)
    println(max)
    val sum = getSum(1,2,3,4,5,6,7)
    println(sum)
  }
  /*
  方式一：标准写法。 需求：定义方法，来获取两个值中的最大值
      默认参数：在定义方法的时候，参数会给个默认值
      带名参数：在调用方法的时候，可以按照参数的顺序，也可以按照参数的名称进行传值
   */
  def getMax(a:Int=6,b:Int=7):Int= {
    if(a>b) a else b
  }
  //方式二：优化写法
  def getMax2(a:Int,b:Int) = if(a>b) a else b

  //变长参数：在定义方法的时候，参数前面加一个*号，表示这个参数是变长参数
  // 传入若干个整数，计算其总和
  def getSum(numbers:Int*):Int={
   numbers.sum
  }
}
